home *** CD-ROM | disk | FTP | other *** search
/ American Osteopathic Ass…tion Yearbook 2005 & 2006 / American Osteopathic Association Yearbook 2005 & 2006.iso / pc / server / mmserv.exe / pprint.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2004-07-21  |  8.8 KB  |  294 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.3)
  3.  
  4. import sys as _sys
  5. from cStringIO import StringIO as _StringIO
  6. __all__ = [
  7.     'pprint',
  8.     'pformat',
  9.     'isreadable',
  10.     'isrecursive',
  11.     'saferepr',
  12.     'PrettyPrinter']
  13. _commajoin = ', '.join
  14. _id = id
  15. _len = len
  16. _type = type
  17.  
  18. def pprint(object, stream = None):
  19.     printer = PrettyPrinter(stream = stream)
  20.     printer.pprint(object)
  21.  
  22.  
  23. def pformat(object):
  24.     return PrettyPrinter().pformat(object)
  25.  
  26.  
  27. def saferepr(object):
  28.     return _safe_repr(object, { }, None, 0)[0]
  29.  
  30.  
  31. def isreadable(object):
  32.     return _safe_repr(object, { }, None, 0)[1]
  33.  
  34.  
  35. def isrecursive(object):
  36.     return _safe_repr(object, { }, None, 0)[2]
  37.  
  38.  
  39. class PrettyPrinter:
  40.     
  41.     def __init__(self, indent = 1, width = 80, depth = None, stream = None):
  42.         indent = int(indent)
  43.         width = int(width)
  44.         self._depth = depth
  45.         self._indent_per_level = indent
  46.         self._width = width
  47.         if stream is not None:
  48.             self._stream = stream
  49.         else:
  50.             self._stream = _sys.stdout
  51.  
  52.     
  53.     def pprint(self, object):
  54.         self._stream.write(self.pformat(object) + '\n')
  55.  
  56.     
  57.     def pformat(self, object):
  58.         sio = _StringIO()
  59.         self._format(object, sio, 0, 0, { }, 0)
  60.         return sio.getvalue()
  61.  
  62.     
  63.     def isrecursive(self, object):
  64.         return self.format(object, { }, 0, 0)[2]
  65.  
  66.     
  67.     def isreadable(self, object):
  68.         (s, readable, recursive) = self.format(object, { }, 0, 0)
  69.         if readable:
  70.             pass
  71.         return not recursive
  72.  
  73.     
  74.     def _format(self, object, stream, indent, allowance, context, level):
  75.         level = level + 1
  76.         objid = _id(object)
  77.         if objid in context:
  78.             stream.write(_recursion(object))
  79.             self._recursive = True
  80.             self._readable = False
  81.             return None
  82.         
  83.         rep = self._repr(object, context, level - 1)
  84.         typ = _type(object)
  85.         sepLines = _len(rep) > self._width - 1 - indent - allowance
  86.         write = stream.write
  87.         if sepLines:
  88.             if typ is dict:
  89.                 write('{')
  90.                 if self._indent_per_level > 1:
  91.                     write((self._indent_per_level - 1) * ' ')
  92.                 
  93.                 length = _len(object)
  94.                 if length:
  95.                     context[objid] = 1
  96.                     indent = indent + self._indent_per_level
  97.                     items = object.items()
  98.                     items.sort()
  99.                     (key, ent) = items[0]
  100.                     rep = self._repr(key, context, level)
  101.                     write(rep)
  102.                     write(': ')
  103.                     self._format(ent, stream, indent + _len(rep) + 2, allowance + 1, context, level)
  104.                     if length > 1:
  105.                         for key, ent in items[1:]:
  106.                             rep = self._repr(key, context, level)
  107.                             write(',\n%s%s: ' % (' ' * indent, rep))
  108.                             self._format(ent, stream, indent + _len(rep) + 2, allowance + 1, context, level)
  109.                         
  110.                     
  111.                     indent = indent - self._indent_per_level
  112.                     del context[objid]
  113.                 
  114.                 write('}')
  115.                 return None
  116.             
  117.             if typ is list or typ is tuple:
  118.                 if typ is list:
  119.                     write('[')
  120.                     endchar = ']'
  121.                 else:
  122.                     write('(')
  123.                     endchar = ')'
  124.                 if self._indent_per_level > 1:
  125.                     write((self._indent_per_level - 1) * ' ')
  126.                 
  127.                 length = _len(object)
  128.                 if length:
  129.                     context[objid] = 1
  130.                     indent = indent + self._indent_per_level
  131.                     self._format(object[0], stream, indent, allowance + 1, context, level)
  132.                     if length > 1:
  133.                         for ent in object[1:]:
  134.                             write(',\n' + ' ' * indent)
  135.                             self._format(ent, stream, indent, allowance + 1, context, level)
  136.                         
  137.                     
  138.                     indent = indent - self._indent_per_level
  139.                     del context[objid]
  140.                 
  141.                 if typ is tuple and length == 1:
  142.                     write(',')
  143.                 
  144.                 write(endchar)
  145.                 return None
  146.             
  147.         
  148.         write(rep)
  149.  
  150.     
  151.     def _repr(self, object, context, level):
  152.         (repr, readable, recursive) = self.format(object, context.copy(), self._depth, level)
  153.         if not readable:
  154.             self._readable = False
  155.         
  156.         if recursive:
  157.             self._recursive = True
  158.         
  159.         return repr
  160.  
  161.     
  162.     def format(self, object, context, maxlevels, level):
  163.         return _safe_repr(object, context, maxlevels, level)
  164.  
  165.  
  166.  
  167. def _safe_repr(object, context, maxlevels, level):
  168.     typ = _type(object)
  169.     if typ is str:
  170.         if 'locale' not in _sys.modules:
  171.             return (`object`, True, False)
  172.         
  173.         if "'" in object and '"' not in object:
  174.             closure = '"'
  175.             quotes = {
  176.                 '"': '\\"' }
  177.         else:
  178.             closure = "'"
  179.             quotes = {
  180.                 "'": "\\'" }
  181.         qget = quotes.get
  182.         sio = _StringIO()
  183.         write = sio.write
  184.         for char in object:
  185.             if char.isalpha():
  186.                 write(char)
  187.                 continue
  188.             write(qget(char, `char`[1:-1]))
  189.         
  190.         return ('%s%s%s' % (closure, sio.getvalue(), closure), True, False)
  191.     
  192.     if typ is dict:
  193.         if not object:
  194.             return ('{}', True, False)
  195.         
  196.         objid = _id(object)
  197.         if maxlevels and level > maxlevels:
  198.             return ('{...}', False, objid in context)
  199.         
  200.         if objid in context:
  201.             return (_recursion(object), False, True)
  202.         
  203.         context[objid] = 1
  204.         readable = True
  205.         recursive = False
  206.         components = []
  207.         append = components.append
  208.         level += 1
  209.         saferepr = _safe_repr
  210.         for k, v in object.iteritems():
  211.             (krepr, kreadable, krecur) = saferepr(k, context, maxlevels, level)
  212.             (vrepr, vreadable, vrecur) = saferepr(v, context, maxlevels, level)
  213.             append('%s: %s' % (krepr, vrepr))
  214.             if readable and kreadable:
  215.                 pass
  216.             readable = vreadable
  217.             if krecur or vrecur:
  218.                 recursive = True
  219.                 continue
  220.         
  221.         del context[objid]
  222.         return ('{%s}' % _commajoin(components), readable, recursive)
  223.     
  224.     if typ is list or typ is tuple:
  225.         if typ is list:
  226.             if not object:
  227.                 return ('[]', True, False)
  228.             
  229.             format = '[%s]'
  230.         elif _len(object) == 1:
  231.             format = '(%s,)'
  232.         elif not object:
  233.             return ('()', True, False)
  234.         
  235.         format = '(%s)'
  236.         objid = _id(object)
  237.         if maxlevels and level > maxlevels:
  238.             return (format % '...', False, objid in context)
  239.         
  240.         if objid in context:
  241.             return (_recursion(object), False, True)
  242.         
  243.         context[objid] = 1
  244.         readable = True
  245.         recursive = False
  246.         components = []
  247.         append = components.append
  248.         level += 1
  249.         for o in object:
  250.             (orepr, oreadable, orecur) = _safe_repr(o, context, maxlevels, level)
  251.             append(orepr)
  252.             if not oreadable:
  253.                 readable = False
  254.             
  255.             if orecur:
  256.                 recursive = True
  257.                 continue
  258.         
  259.         del context[objid]
  260.         return (format % _commajoin(components), readable, recursive)
  261.     
  262.     rep = `object`
  263.     if rep:
  264.         pass
  265.     return (rep, not rep.startswith('<'), False)
  266.  
  267.  
  268. def _recursion(object):
  269.     return '<Recursion on %s with id=%s>' % (_type(object).__name__, _id(object))
  270.  
  271.  
  272. def _perfcheck(object = None):
  273.     import time
  274.     if object is None:
  275.         object = [
  276.             ('string', (1, 2), [
  277.                 3,
  278.                 4], {
  279.                 5: 6,
  280.                 7: 8 })] * 100000
  281.     
  282.     p = PrettyPrinter()
  283.     t1 = time.time()
  284.     _safe_repr(object, { }, None, 0)
  285.     t2 = time.time()
  286.     p.pformat(object)
  287.     t3 = time.time()
  288.     print '_safe_repr:', t2 - t1
  289.     print 'pformat:', t3 - t2
  290.  
  291. if __name__ == '__main__':
  292.     _perfcheck()
  293.  
  294.